import axios from 'axios'
import { useUserStore } from '@/stores/user.js'

// 判断是否使用模拟数据
const USE_MOCK = false; // 设置为true启用模拟数据，false使用真实API

// 如果启用模拟数据，则导入模拟API
if (USE_MOCK) {
  // 动态导入模拟API（仅在开发环境使用）
  import('./mock.js').then(mock => {
    console.log('已启用API模拟数据')
  })
}

// 创建axios实例
const api = axios.create({
  // API服务器基础URL
  baseURL: import.meta.env.VITE_API_BASE_URL || '',
  timeout: parseInt(import.meta.env.VITE_API_TIMEOUT || '15000'), // 从环境变量读取超时时间
  headers: {
    'Content-Type': 'application/json'
  },
  // 允许跨域携带cookie凭证
  withCredentials: true
})

// 启用调试模式
const DEBUG = import.meta.env.VITE_ENABLE_DEBUG === 'true'

// 请求拦截器 - 添加token等认证信息
api.interceptors.request.use(
  config => {
    if (DEBUG) {
      console.log('发送请求:', config.url, config.method)
      
      // 记录请求数据
      if (config.data) {
        console.log('请求数据:', config.data)
      }
    }
    
    // 尝试从Pinia获取token，如果Pinia还没准备好，则从localStorage获取
    let token
    try {
      const userStore = useUserStore()
      token = userStore.token
    } catch (e) {
      // 如果Pinia还没准备好，从localStorage获取
      token = localStorage.getItem('token')
    }
    
    if (token) {
      // 将token添加到auth请求头中，而不是Authorization
      config.headers['auth'] = token
    }
    
    return config
  },
  error => {
    if (DEBUG) {
      console.error('请求拦截器错误:', error)
    }
    return Promise.reject(error)
  }
)

// 响应拦截器 - 处理错误
api.interceptors.response.use(
  response => {
    if (DEBUG) {
      console.log('收到响应:', response.status, response.config.url)
      console.log('响应数据:', response.data)
    }
    return response.data
  },
  error => {
    if (DEBUG) {
      console.error('API请求错误:', error)
      
      if (error.response) {
        console.error(`请求失败: ${error.response.status} ${error.response.statusText}`)
        console.error('请求URL:', error.config.url)
        console.error('请求方法:', error.config.method)
        console.error('请求数据:', error.config.data)
        console.error('响应数据:', error.response.data)
      } else if (error.request) {
        console.error('服务器无响应，请检查服务器是否正常运行')
        console.error('请求URL:', error.config.url)
        console.error('请求方法:', error.config.method)
        console.error('请求数据:', error.config.data)
      } else {
        // 请求设置触发的错误
        console.error('请求配置错误:', error.message)
      }
    }
    
    if (error.response) {
      // 处理错误响应
      switch (error.response.status) {
        case 401:
          // 未授权，清除token并跳转到登录页
          try {
            const userStore = useUserStore()
            userStore.logout()
          } catch (e) {
            // 如果Pinia还没准备好，从localStorage清除
            localStorage.removeItem('token')
            localStorage.removeItem('isLoggedIn')
            localStorage.removeItem('adminInfo')
          }
          
          console.error('认证失败: 用户未登录或登录已过期')
          break
        case 403:
          // 禁止访问
          console.error('没有权限访问此资源')
          break
        case 500:
          // 服务器错误
          console.error('服务器错误，请稍后再试')
          break
        default:
          console.error(`请求错误: ${error.response.data?.message || '未知错误'}`)
      }
    } else if (error.request) {
      // 请求已发送但没有收到响应
      console.error('服务器无响应，请检查服务器是否正常运行')
    } else {
      // 请求设置触发的错误
      console.error('请求配置错误:', error.message)
    }
    return Promise.reject(error)
  }
)

// 管理员登录接口
export const adminLogin = (username, password) => {
  // 确保请求体格式符合API文档规范
  return api.post('/api/admin/login', {
    username: username,
    password: password
  })
  .then(response => {
    console.log('登录响应:', response)
    // 处理不同的响应结构
    if (response.error === 0 && response.body) {
      // 标准成功响应结构
      return {
        admin: response.body.admin,
        token: response.body.token,
        message: response.message
      }
    } else if (response.token) {
      // 另一种可能的响应结构
      return {
        admin: response.admin || {},
        token: response.token,
        message: response.message || '登录成功'
      }
    }
    // 如果响应格式不符合预期，原样返回
    return response
  })
}

/**
 * 获取商品列表
 * @param {Object} params - 查询参数
 * @param {number} [params.page=1] - 当前页码
 * @param {number} [params.limit=10] - 每页数量
 * @param {string} [params.category] - 商品分类ID
 * @param {string} [params.keyword] - 搜索关键词
 * @param {string} [params.sort='createTime'] - 排序字段
 * @param {string} [params.order='desc'] - 排序方向(asc/desc)
 * @returns {Promise} - API响应Promise
 */
export const getProducts = (params = {}) => {
  // 设置默认参数
  const defaultParams = {
    page: 1,
    limit: 10,
    sort: 'createTime',
    order: 'desc'
  }

  // 合并默认参数和用户传入参数
  const queryParams = { ...defaultParams, ...params }
  
  return api.get('/api/products', { params: queryParams })
  .then(response => {
    if (DEBUG) {
      console.log('获取商品列表响应:', response)
    }
    
    // 处理响应
    if (response.error === 0 && response.body) {
      return {
        products: response.body.products,
        total: response.body.total,
        pages: response.body.pages,
        page: response.body.page,
        message: response.message
      }
    }
    
    // 如果响应格式不符合预期，原样返回
    return response
  })
}

/**
 * 获取商品分类列表
 * @param {Object} params - 查询参数
 * @param {string} [params.parentId] - 父分类ID，传入'null'表示获取顶级分类
 * @returns {Promise} - API响应Promise
 */
export const getCategories = (params = {}) => {
  return api.get('/api/categories', { params })
  .then(response => {
    if (DEBUG) {
      console.log('获取商品分类列表响应:', response)
    }
    
    // 处理响应
    if (response && response.code === 200) {
      return {
        categories: response.data,
        message: response.message
      }
    }
    
    // 如果响应格式不符合预期，原样返回并记录错误
    console.error('获取分类列表响应格式错误:', response)
    return {
      categories: [],
      message: response?.message || '获取分类列表失败'
    }
  })
  .catch(error => {
    console.error('获取分类列表出错:', error)
    return {
      categories: [],
      message: '获取分类列表时发生错误'
    }
  })
}

/**
 * 获取商品分类树形结构
 * @returns {Promise} - API响应Promise
 */
export const getCategoriesTree = () => {
  return api.get('/api/categories/tree')
  .then(response => {
    if (DEBUG) {
      console.log('获取商品分类树形结构响应:', response)
    }
    
    // 处理响应
    if (response && response.code === 200) {
      return {
        categories: response.data,
        message: response.message
      }
    }
    
    // 如果响应格式不符合预期，原样返回并记录错误
    console.error('获取分类树形结构响应格式错误:', response)
    return {
      categories: [],
      message: response?.message || '获取分类树形结构失败'
    }
  })
  .catch(error => {
    console.error('获取分类树形结构出错:', error)
    return {
      categories: [],
      message: '获取分类树形结构时发生错误'
    }
  })
}

/**
 * 搜索商品
 * @param {Object} params - 搜索参数
 * @param {string} params.keyword - 搜索关键词
 * @param {number} [params.page=1] - 当前页码
 * @param {number} [params.limit=10] - 每页数量
 * @param {string} [params.sort='createTime'] - 排序字段
 * @param {string} [params.order='desc'] - 排序方向(asc/desc)
 * @returns {Promise} - API响应Promise
 */
export const searchProducts = (params = {}) => {
  // 验证必填参数
  if (!params.keyword) {
    return Promise.reject(new Error('搜索关键词不能为空'));
  }
  
  // 设置默认参数
  const defaultParams = {
    page: 1,
    limit: 10,
    sort: 'createTime',
    order: 'desc'
  };

  // 合并默认参数和用户传入参数
  const queryParams = { ...defaultParams, ...params };
  
  return api.get('/api/products/search', { params: queryParams })
  .then(response => {
    if (DEBUG) {
      console.log('搜索商品响应:', response);
    }
    
    // 处理响应
    if (response.error === 0 && response.body) {
      return {
        products: response.body.products,
        total: response.body.total,
        pages: response.body.pages,
        page: response.body.page,
      };
    } else {
      throw new Error(response.message || '搜索商品失败');
    }
  });
};

/**
 * 创建新商品
 * @param {Object} data - 商品数据，包括文件
 * @returns {Promise} - API响应Promise
 */
export const createProduct = (data) => {
  // 验证必填字段
  if (!data.name || !data.price || !data.stock || !data.description) {
    return Promise.reject(new Error('商品名称、价格、库存、描述为必填项'));
  }
  
  // 创建FormData对象
  const formData = new FormData();
  
  // 添加基本表单字段
  for (const key in data) {
    if (key === 'images') {
      // 处理图片文件列表
      if (Array.isArray(data.images)) {
        data.images.forEach(file => {
          formData.append('images', file);
        });
      } else if (data.images) {
        // 单个文件
        formData.append('images', data.images);
      }
    } else if (key === 'tags' || key === 'specs') {
      // 处理数组或对象类型数据，转为JSON字符串
      if (data[key] && typeof data[key] === 'object') {
        formData.append(key, JSON.stringify(data[key]));
      } else {
        formData.append(key, data[key]);
      }
    } else {
      // 其他普通字段
      formData.append(key, data[key]);
    }
  }
  
  // 发送请求
  return api.post('/api/products', formData, {
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  })
  .then(response => {
    if (DEBUG) {
      console.log('创建商品响应:', response);
    }
    
    // 处理响应
    if (response.code === 201 && response.data) {
      return {
        product: response.data,
        message: response.message
      };
    } else {
      throw new Error(response.message || '创建商品失败');
    }
  });
};

/**
 * 更新商品信息
 * @param {string} id - 商品ID
 * @param {Object} data - 更新的商品数据，包括文件
 * @returns {Promise} - API响应Promise
 */
export const updateProduct = (id, data) => {
  if (!id) {
    return Promise.reject(new Error('商品ID不能为空'));
  }
  
  // 创建FormData对象
  const formData = new FormData();
  
  // 添加基本表单字段
  for (const key in data) {
    if (key === 'images') {
      // 处理新上传的图片文件列表
      if (Array.isArray(data.images)) {
        data.images.forEach(file => {
          // 只添加文件类型的图片，字符串类型的URL会通过existingImages处理
          if (file instanceof File) {
            formData.append('images', file);
          }
        });
      } else if (data.images instanceof File) {
        // 单个文件
        formData.append('images', data.images);
      }
    } else if (key === 'existingImages') {
      // 处理保留的原图片URL数组
      if (Array.isArray(data.existingImages)) {
        formData.append('existingImages', JSON.stringify(data.existingImages));
      }
    } else if (key === 'tags' || key === 'specs') {
      // 处理数组或对象类型数据，转为JSON字符串
      if (data[key] && typeof data[key] === 'object') {
        formData.append(key, JSON.stringify(data[key]));
      } else {
        formData.append(key, data[key]);
      }
    } else {
      // 其他普通字段
      formData.append(key, data[key]);
    }
  }
  
  // 发送请求
  return api.put(`/api/products/${id}`, formData, {
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  })
  .then(response => {
    if (DEBUG) {
      console.log('更新商品响应:', response);
    }
    
    // 处理响应
    if (response.code === 200 && response.data) {
      return {
        product: response.data,
        message: response.message || '商品更新成功'
      };
    } else {
      throw new Error(response.message || '更新商品失败');
    }
  });
};

/**
 * 商品上架
 * @param {string} id - 商品ID
 * @returns {Promise} - API响应Promise
 */
export const publishProduct = (id) => {
  if (!id) {
    return Promise.reject(new Error('商品ID不能为空'));
  }
  
  if (DEBUG) {
    console.log(`准备上架商品，ID: ${id}`);
  }
  
  // 使用简化的方式，确保传递空对象作为请求体
  return api.patch(`/api/products/${id}/publish`, {})
  .then(response => {
    if (DEBUG) {
      console.log('商品上架响应:', response);
    }
    
    // 处理响应 - 严格按照API文档格式处理
    if (response && response.code === 200) {
      return {
        success: true,
        product: response.data,
        message: response.message || '商品上架成功'
      };
    } else {
      // 处理非标准成功响应，向下兼容
      if ((response.error === 0 && response.body) || response.status === 'success') {
        return {
          success: true,
          product: response.data || response.body || {},
          message: response.message || '商品上架成功'
        };
      }
      
      // 如果响应不符合任何预期格式，则抛出错误
      throw new Error(response.message || '商品上架失败，服务器返回数据格式不正确');
    }
  })
  .catch(error => {
    console.error('上架商品API错误:', error);
    // 捕获并重新包装错误，提供更详细的错误信息
    if (error.response) {
      const statusCode = error.response.status;
      const responseData = error.response.data;
      
      if (statusCode === 400) {
        return {
          success: false,
          message: responseData?.message || '商品上架失败：请求参数不正确'
        };
      } else if (statusCode === 401) {
        return {
          success: false,
          message: '商品上架失败：未授权，请重新登录'
        };
      } else if (statusCode === 404) {
        return {
          success: false,
          message: '商品上架失败：商品不存在'
        };
      } else {
        return {
          success: false,
          message: responseData?.message || `商品上架失败：服务器错误(${statusCode})`
        };
      }
    }
    
    return {
      success: false,
      message: error.message || '商品上架失败：网络错误'
    };
  });
};

/**
 * 商品下架
 * @param {string} id - 商品ID
 * @returns {Promise} - API响应Promise
 */
export const unpublishProduct = (id) => {
  if (!id) {
    return Promise.reject(new Error('商品ID不能为空'));
  }
  
  if (DEBUG) {
    console.log(`准备下架商品，ID: ${id}`);
  }
  
  // 使用简化的方式，确保传递空对象作为请求体
  return api.patch(`/api/products/${id}/unpublish`, {})
  .then(response => {
    if (DEBUG) {
      console.log('商品下架响应:', response);
    }
    
    // 处理响应 - 严格按照API文档格式处理
    if (response && response.code === 200) {
      return {
        success: true,
        product: response.data,
        message: response.message || '商品下架成功'
      };
    } else {
      // 处理非标准成功响应，向下兼容
      if ((response.error === 0 && response.body) || response.status === 'success') {
        return {
          success: true,
          product: response.data || response.body || {},
          message: response.message || '商品下架成功'
        };
      }
      
      // 如果响应不符合任何预期格式，则抛出错误
      throw new Error(response.message || '商品下架失败，服务器返回数据格式不正确');
    }
  })
  .catch(error => {
    console.error('下架商品API错误:', error);
    // 捕获并重新包装错误，提供更详细的错误信息
    if (error.response) {
      const statusCode = error.response.status;
      const responseData = error.response.data;
      
      if (statusCode === 400) {
        return {
          success: false,
          message: responseData?.message || '商品下架失败：请求参数不正确'
        };
      } else if (statusCode === 401) {
        return {
          success: false,
          message: '商品下架失败：未授权，请重新登录'
        };
      } else if (statusCode === 404) {
        return {
          success: false,
          message: '商品下架失败：商品不存在'
        };
      } else {
        return {
          success: false,
          message: responseData?.message || `商品下架失败：服务器错误(${statusCode})`
        };
      }
    }
    
    return {
      success: false,
      message: error.message || '商品下架失败：网络错误'
    };
  });
};

/**
 * 删除商品（软删除）
 * @param {string} id - 商品ID
 * @returns {Promise} - API响应Promise
 */
export const deleteProduct = (id) => {
  if (!id) {
    return Promise.reject(new Error('商品ID不能为空'));
  }
  
  if (DEBUG) {
    console.log(`准备删除商品，ID: ${id}`);
  }
  
  // 使用空对象作为请求体，确保Content-Type正确设置
  return api.delete(`/api/products/${id}`, {
    headers: {
      'Content-Type': 'application/json'
    },
    data: {}  // 添加空对象作为请求体
  })
  .then(response => {
    if (DEBUG) {
      console.log('商品删除响应:', response);
    }
    
    // 处理响应 - 按照API文档格式处理
    if (response && response.code === 200) {
      return {
        success: true,
        message: response.message || '商品删除成功'
      };
    } else {
      // 如果响应不符合预期格式，则抛出错误
      throw new Error(response.message || '商品删除失败，服务器返回数据格式不正确');
    }
  })
  .catch(error => {
    console.error('删除商品API错误:', error);
    // 捕获并重新包装错误，提供更详细的错误信息
    if (error.response) {
      const statusCode = error.response.status;
      const responseData = error.response.data;
      
      if (statusCode === 401) {
        return {
          success: false,
          message: '商品删除失败：未授权，请重新登录'
        };
      } else if (statusCode === 404) {
        return {
          success: false,
          message: '商品删除失败：商品不存在'
        };
      } else {
        return {
          success: false,
          message: responseData?.message || `商品删除失败：服务器错误(${statusCode})`
        };
      }
    }
    
    return {
      success: false,
      message: error.message || '商品删除失败：网络错误'
    };
  });
};

/**
 * 创建商品分类
 * @param {Object} data - 分类数据
 * @returns {Promise} - API响应Promise
 */
export const createCategory = (data) => {
  // 验证必填字段
  if (!data.name) {
    return Promise.reject(new Error('分类名称为必填项'));
  }
  
  return api.post('/api/categories', data, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
  .then(response => {
    if (DEBUG) {
      console.log('创建分类响应:', response);
    }
    
    // 处理响应
    if (response && response.code === 201) {
      return {
        success: true,
        category: response.data,
        message: response.message || '分类创建成功'
      };
    } else {
      throw new Error(response?.message || '创建分类失败');
    }
  })
  .catch(error => {
    console.error('创建分类API错误:', error);
    if (error.response) {
      throw new Error(error.response.data?.message || `服务器错误: ${error.response.status}`);
    } else if (error.request) {
      throw new Error('服务器无响应，请检查网络连接');
    } else {
      throw error;
    }
  });
};

/**
 * 更新商品分类
 * @param {string} id - 分类ID
 * @param {Object} data - 更新的分类数据
 * @returns {Promise} - API响应Promise
 */
export const updateCategory = (id, data) => {
  if (!id) {
    return Promise.reject(new Error('分类ID不能为空'));
  }
  
  // 根据API文档，只发送必要的字段
  const apiData = {};
  
  // 只添加被修改且API支持的字段
  if (data.name !== undefined) {
    apiData.name = data.name;
  }
  
  if (data.icon !== undefined) {
    apiData.icon = data.icon;
  }
  
  if (data.sort !== undefined) {
    apiData.sort = data.sort;
  }
  
  if (data.parentId !== undefined) {
    apiData.parentId = data.parentId;
  }
  
  // 可选添加其他字段 - 根据API文档，这些字段可能不是标准字段
  if (data.isActive !== undefined) {
    apiData.isActive = data.isActive;
  }
  
  if (DEBUG) {
    console.log(`准备更新分类，ID: ${id}，数据:`, apiData);
  }
  
  return api.put(`/api/categories/${id}`, apiData, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
  .then(response => {
    if (DEBUG) {
      console.log('更新分类响应:', response);
    }
    
    // 处理响应
    if (response && response.code === 200) {
      return {
        success: true,
        category: response.data,
        message: response.message || '分类更新成功'
      };
    } else {
      throw new Error(response?.message || '更新分类失败');
    }
  })
  .catch(error => {
    console.error('更新分类API错误:', error);
    // 根据API文档提供更详细的错误信息
    if (error.response) {
      const statusCode = error.response.status;
      const responseData = error.response.data;
      
      if (statusCode === 400) {
        return {
          success: false,
          message: responseData?.message || '更新分类失败：请求参数错误(可能是父分类不存在)'
        };
      } else if (statusCode === 401) {
        return {
          success: false,
          message: '更新分类失败：未授权，请重新登录'
        };
      } else if (statusCode === 404) {
        return {
          success: false,
          message: '更新分类失败：分类不存在'
        };
      } else {
        return {
          success: false,
          message: responseData?.message || `更新分类失败：服务器错误(${statusCode})`
        };
      }
    }
    
    return {
      success: false,
      message: error.message || '更新分类失败：网络错误'
    };
  });
};

/**
 * 删除商品分类
 * @param {string} id - 分类ID
 * @returns {Promise} - API响应Promise
 */
export const deleteCategory = (id) => {
  if (!id) {
    return Promise.reject(new Error('分类ID不能为空'));
  }
  
  return api.delete(`/api/categories/${id}`, {
    headers: {
      'Content-Type': 'application/json'
    },
    data: {}  // 添加空对象作为请求体
  })
  .then(response => {
    if (DEBUG) {
      console.log('删除分类响应:', response);
    }
    
    // 处理响应
    if (response && response.code === 200) {
      return {
        success: true,
        message: response.message || '分类删除成功'
      };
    } else {
      throw new Error(response?.message || '删除分类失败');
    }
  })
  .catch(error => {
    console.error('删除分类API错误:', error);
    if (error.response) {
      throw new Error(error.response.data?.message || `服务器错误: ${error.response.status}`);
    } else if (error.request) {
      throw new Error('服务器无响应，请检查网络连接');
    } else {
      throw error;
    }
  });
};

// 导出API实例
export default api 